<?php
  /**
   *数组函数
   */
  trait Arr
  {

    public function arr(){
			$pets=array("a"=>"Cat","B"=>"Dog","c"=>"Horse","b"=>"Bird",10=>'Abcd');
			$double = array(
			array(
			'id' => 5698,
			'first_name' => 'Bill',
			'last_name' => 'Gates',
			),
			array(
			'id' => 4767,
			'first_name' => 'Steve',
			'last_name' => 'Jobs',
			),
			array(
			'id' => 3809,
			'first_name' => 'Mark',
			'last_name' => 'Zuckerberg',
			'exists' => 1,
			)
			);

			$arr = array(1,2,3);

			/**
			 * 扩充
			 * 按位与&：两位全为1，结果为1
			 * 按位或|：两位有一个为1，结果为1
			 * 按位异或^：两位一个为0，一个为1，结果为1
			 * 按位取反~：0变成1,1变成01
			 */

			 //【自定义函数】按【键名】排序,!!重排索引!!
			 $this->pri($pets);
			 function emp(){}
			 function ua($a,$b){
				 return ($a>$b)? 1 : -1;	//升序
				//  return ($a>$b)? -1 : 1;	//降序
			 }
			 usort($pets,"emp");
			 $this->pri($pets);
			 usort($pets,"ua");
			 $this->pri($pets);
			 return;

			 //【自定义函数】按【键名】排序
			 $this->pri($pets);
			 function emp(){}
			 function ua($a,$b){
				//  return ($a>$b)? 1 : -1;	//升序
				 return ($a>$b)? -1 : 1;	//降序
			 }
			 uksort($pets,"emp");
			 $this->pri($pets);
			 uksort($pets,"ua");
			 $this->pri($pets);
			 return;

			 //【自定义函数】按【键值】排序
			 $this->pri($pets);
			 function emp(){}
			 function ua($a,$b){
				 return ($a>$b)? 1 : -1;	//升序
				//  return ($a>$b)? -1 : 1;	//降序
			 }
			 uasort($pets,"emp");
			 $this->pri($pets);
			 uasort($pets,"ua");
			 $this->pri($pets);
			 return;

			 //count别名【sizeof】!!二参设置为1则递归计算多维数组!!
			 echo sizeof($double);
			 echo '<br/>'.sizeof($double,1);
			 return;

			 //随机打乱数组元素排序[F5]
			 $this->pri($pets);
			 shuffle($pets);
			 $this->pri($pets);
			 return;

			 //倒序,二参是指定类型,见w3c
			 $this->pri($pets);
			 rsort($pets);
			 $this->pri($pets);
			 $arr = array(3,5,1,11);
			 rsort($arr);
			 $this->pri($arr);
			 return;

			 //数组元素按字母升序排序,【忽略键名】(数字也能排)
			 $this->pri($pets);
			 sort($pets);
			 $this->pri($pets);
			 $arr = array(3,5,1,11);
			 sort($arr);
			 $this->pri($arr);
			 return;

			 //创建一个包含从 low 到 high 之间的元素的数组
			 //如果 low 参数大于 high 参数，则创建的数组【键值】将是从 high 到 low。
			 //三参是【键值】的进步制(就是加几加几)
			 $arr = range(0,3);
			 $this->pri($arr);
			 $arr2 = range(0,100,25);
			 $this->pri($arr2);
			 return;

			 //current的别名,显示当前指针键值
			 echo pos($pets);
			 $this->pri(pos($double));
			 return;

			 //按数组键值【自然排序】【大小写不敏感】,保留键名
			 $arr = array('T15','T2','t5','t10');
			 natcasesort($arr);
			 $this->pri($arr);
			 return;

			 //按数组键值【自然排序】【大小写敏感】,保留键名,按自然数排序15>2
			 $arr = array('T15','T2','t5','t10');
			 natsort($arr);
			 $this->pri($arr);
			 		//按计算机排序15<2因为1<2
			 asort($arr);
			 $this->pri($arr);
			 return;

			 //返回当前指针的键名
			 echo key($pets);
			 next($pets);
			 echo '<br/>'.key($pets);
			 return;

			 //搜索数组值,区分大小写,三参为true则全等匹配(===)
			 var_dump(in_array('Dog',$pets));
			 $arr = array('a','B','b');
			 echo '<br/>';
			 var_dump(in_array('A',$arr));
			 $arr = array(1,'1',2);
			 echo '<br/>';
			 var_dump(in_array('2',$arr));
			 echo '<br/>';
			 var_dump(in_array('2',$arr,true));
			 return;

			 //将数组元素给变量赋值,变量名为键名,变量值为键值
			 //二参监测变量名是否重复(冲突),解决方式见w3c,加后缀,后缀为三参
			 $b = 'first';
			 $arr = array("a"=>1,"a"=>2,"b"=>3);
			 extract($arr,EXTR_PREFIX_SAME,"zxy");
			 echo $a,$b,$zxy_b;
			 $this->pri($arr);
					return;
			 extract($pets);
			 echo $a,$B,$c,$b;
			 return;

			 //list+each遍历数组
			 //因为each只识别索引数组,所以可以这么干,!二维整不了!
			 while (list($k,$v) = each($pets)) {
				 echo $k.'=>'.$v.'<br/>';
			 }
			 return;

			 //把数组中的一些值赋给变量,!!仅识别索引数组!!,会跳过关联数组部分
			 //list原理：第一个元素被下标为0的赋值，第二个元素被下标为1的赋值，以此类推。
			 //可用空(或空格都行)跳过某个元素
			 $arr = array(1,2,3);
			 list($a, $b) = $arr;
			 echo $a,$b;

			 list($a,,$c) = $arr;
			 echo '<br/>'.$a,$c;

			 $arr = array(1,'a'=>2,'b'=>3,4);
			 list($a,$b) = $arr;
			 echo '<br/>'.$a,$b;
			 return;

			 //输出数组的键值对,并将指针向前移动
			 for ($i=0; $i <count($pets) ; $i++) {
				 $this->pri(each($pets));
			 }
			 return;

			 //输出当前数组指针位置键值
			 //current别名!!pos!!
			 echo end($pets);
			 echo current($pets);
			 echo pos($pets);
			 $this->pri(current($double));
			 return;

			 //移到数组第一个
			 echo end($pets);
			 echo reset($pets);
			 return;

			 //指针移到数组最后一个
			 echo end($pets);
			 return;

			 //指针上移一位,超出返回false
			 echo next($pets);
			 echo '<br/>'.prev($pets);
			 echo '<br/>'.current($pets);
			 return;

			 //将数组内部指针向后移一位并输出,超出返回false
			 echo next($pets);
			 echo current($pets);
			 return;

			 //count!!二参设置为1则递归计算多维数组!!
			 echo count($double);
			 echo '<br/>'.count($double,1);
			 return;

			 //创建数组 key为变量名 value为变量值,undefine的变量将被略过
			 //!!参数为变量名!!
			 $a = 1;
			 $b = 2;
			 $this->pri(compact("a","b"));
			 return;

			 //按键名【名】降序排序
			 krsort($pets,SORT_LOCALE_STRING);
			 $this->pri($pets);
			 return;

			 //按键名【名】升序排序
			 ksort($pets);
			 $this->pri($pets);
			 return;

			 //同下,按值降序排序
			 $arr = array(2,4,11,3,'A');
			 arsort($arr,SORT_LOCALE_STRING);
			 $this->pri($arr);
			 return;

			 //对关联数组按键值【值】升序排列元素,二参指定类型
			 asort($pets);
			 $this->pri($pets);
			 $arr = array(2,4,11,3,'A');
			 asort($arr);
			 $this->pri($arr);
			 asort($arr,SORT_LOCALE_STRING);
			 $this->pri($arr);
			 return;

			 //同下,操作多维数组
			 function rec(&$v,$a){
				 $v.='修改过';
			 }
			 array_walk_recursive($double,"rec");
			 $this->pri($double);
			 return;

			 //自定义函数操作数组,建议一维,可传递引用类型键值,可传递无数参数(测试只让传3个)
			 function walk($value,$key){
				 echo "$key=>$value";
			 }
			 array_walk($pets,"walk");
			 		//改变数组值,引用类型
			 function Reference(&$v,$k){
				 $v = 'value';
			 }
			 array_walk($pets,"Reference");
			 $this->pri($pets);
			 		//给自定义函数传多个参数
			 function many($v,$k,$a){
				 echo $a;
			 }
			 array_walk($pets,"many",'第三参');
			 return;

			 //返回数组中所有键值(索引形式),多维递归获取
			 $this->pri(array_values($pets));
			 $this->pri(array_values($double));
			 return;

			 //想数组开头插入新值,新数组按索引重新排,字符键名不变
			 array_unshift($double,'开头插入');
			 $this->pri($double);
			 $arr = array('a','b');
			 array_unshift($arr,'开头插入');
			 $this->pri($arr);
			 return;

			 //删除数组中重复的值,保留键名,只保留重复项第一项键名,二参指定类型
			 $arr = array('a','a','b','b','c','c');
			 $this->pri(array_unique($arr,SORT_NUMERIC));
			 return;

			 //array_uintersect_uassoc()交集【略】
			 //比较两数组【键名和键值】,用自定义函数,返回交集
			 function myfunction($a,$b)
				{
				if ($a===$b)
				  {
				  return 0;
				  }
				  return ($a>$b)?1:-1;
				}

				$a1=array("a"=>"red","b"=>"green","c"=>"blue");
				$a2=array("a"=>"red","b"=>"blue","c"=>"green");

				$result=array_uintersect_assoc($a1,$a2,"myfunction");
				print_r($result);
				return;

			 //比较两数组【键值】,用自定义函数,返回交集
			 function myfunction($a,$b)
				{
				if ($a===$b)
				  {
				  return 0;
				  }
				  return ($a>$b)?1:-1;
				}

				$a1=array("a"=>"red","b"=>"green","c"=>"blue");
				$a2=array("a"=>"blue","b"=>"black","e"=>"blue");

				$result=array_uintersect($a1,$a2,"myfunction");
				print_r($result);
				return;
			 //比较数组【键名和键值】返回差集,用自定义函数【键值分别用在自定义函数】
			 function myfunction_key($a,$b)
				{
				if ($a===$b)
				  {
				  return 0;
				  }
				  return ($a>$b)?1:-1;
				}

				function myfunction_value($a,$b)
				{
				if ($a===$b)
				  {
				  return 0;
				  }
				  return ($a>$b)?1:-1;
				}

				$a1=array("a"=>"red","b"=>"green","c"=>"blue");
				$a2=array("a"=>"red","b"=>"green","c"=>"green");

				$result=array_udiff_uassoc($a1,$a2,"myfunction_key","myfunction_value");
				print_r($result);
				return;

			 //比较数组【键名和键值】返回差集,用自定义函数
			 function myfunction($a,$b)
				{
				if ($a===$b)
				  {
				  return 0;
				  }
				  return ($a>$b)?1:-1;
				}

				$a1=array("a"=>"red","b"=>"green","c"=>"blue");
				$a2=array("a"=>"red","b"=>"blue","c"=>"green");

				$result=array_udiff_assoc($a1,$a2,"myfunction");
				print_r($result);
				return;

			 //比较数组【键值】返回差集,用自定义函数
			 function myfunction($a,$b)
			 {
			 if ($a===$b)
				  {
				  return 0;
				  }
				  return ($a>$b)?-1:1;
			 }

			 $a1=array("a"=>"red","b"=>"green","c"=>"blue");
			 $a2=array("a"=>"blue","b"=>"black","e"=>"blue");

			 $result=array_udiff($a1,$a2,"myfunction");
			 $this->pri($result);
			 return;

			 //数组所有值的和,有一个浮点数 则返回浮点数
			 $arr = array(1,2,3);
			 echo array_sum($arr);
			 $arr = array(1,2,3.33);
			 echo '<br/>'.array_sum($arr);
			 return;

			 //从数组指定位置删除指定长度[并替换新数组],二参start三参length四参替换数组
			 //!!本函数返回值为被删除的数组!!
			 //length=0时,函数从start指定出插入数组(而不是删除)
			 		//只有二参：删除指定位置后所有元素
			 array_splice($double,1,0,$pets);
			 $this->pri($double);
					return;
			 $this->pri(array_splice($double,1,1));
			 		return;
			 array_splice($double,1,1,$pets);
			 $this->pri($double);
			 		return;
			 array_splice($double,1,1);
 			 $this->pri($double);
			 		return;
			 array_splice($double,1);
			 $this->pri($double);
			 return;

			 //从数组指定位置取出指定长度,二参start三参length四参是否重建索引(针对索引数组)
			 $arr = array(0=>1,'a'=>2,1=>3);
			 $this->pri($arr);
			 $this->pri(array_slice($arr,1,2));
			 $this->pri(array_slice($arr,1,2,true));
			 		//return;
			 $this->pri(array_slice($pets,1));
			 $this->pri(array_slice($pets,1,2));
			 		//是否重置键名
			 $this->pri(array_slice($arr,1,2));
			 $this->pri(array_slice($arr,1,2,true));
			 return;



			 //删除数组中第一个元素,若是索引数组则重建索引
			 array_shift($pets);
			 $this->pri($pets);
			 $arr = array(1,2,3);
			 $this->pri($arr);
			 array_shift($arr);
			 $this->pri($arr);
			 return;

			 //搜索数组键值返回第一个键名.三参为true,则(===)全等于
			 $arr = array('1',1,'2');
			 echo array_search(1,$arr);
			 echo '<br/>'.array_search(1,$arr,true);
			 return;

			 //反序数组,二参默认重新索引键名,true保留原键名,只针对索引数组
			 $a=array("a"=>"Volvo","b"=>"BMW","c"=>"Toyota");
			 print_r(array_reverse($a,true));

			 $a=array("Volvo","XC90",array("BMW","Toyota"));
			 $reverse=array_reverse($a);
			 $preserve=array_reverse($a,true);
			 $this->pri($a);
			 $this->pri($reverse);
			 $this->pri($preserve);
			return;
			 //递归替换数组,适用于多维,递归到每一层
			 $a1=array("a"=>array("red"),"b"=>array("green","blue"),);
			 $a2=array("a"=>array("yellow"),"b"=>array("black"));
			 $result=array_replace_recursive($a1,$a2);
			 $this->pri($result);
			 $result=array_replace($a1,$a2);
			 $this->pri($result);
			 return;

			 //数组替换,多数组按顺序依次替换,键名重复覆盖,不重复一概出现在返回数组里
			 $result = array_replace(array(1,2,3),array(4,5),$pets);
			 $this->pri($result);
			 return;

			 //向用户自定义函数发送数组中的值，并返回一个字符串。
			 //三参当做数组第一项处理
			 function arr($v1,$v2){
				 return $v1.'-'.$v2;
			 }
			 $this->pri(array_reduce($pets,"arr"));
			 $this->pri(array_reduce($pets,"arr",'start'));//string
			 echo array_reduce($pets,"arr",'start');
			 return;

			 //随机键名,随机出一个,二参是随机选出n个(F5)
			 $this->pri(array_rand($pets,2));
			 return;

			 //数组尾部插入(入栈),无一参报错,等价于$var[] = array();
			 array_push($pets,'尾部插入','balabala');
			 $this->pri($pets);
			 //二者区别在于无数组push会报错,$var[]则直接创建新数组(因为弱类型)
			 $arr[] = '1';
			 var_dump($arr);
			 return;

			 //计算数组整数或浮点数的乘积
			 //自 PHP 5.3.6 起，空数组的乘积为 1。在 PHP 5.3.6 之前，空数组的乘积为 0。
			 $arr = array(1,2,3);
			 $arr2 = array(0=>2,1=>3);
			 echo array_product($arr);
			 echo '<br/>'.array_product($pets);
			 echo '<br/>'.array_product($arr2);
			 return;

			 //删除数组中最后一个元素,多维按大维删除
			 array_pop($pets);
			 $this->pri($pets);
			 array_pop($double);
			 $this->pri($double);
			 return;

			 //向无数组中插入元素,二参为返回数组长度,均用三参填充,二参为负则从开头插入
			 $result = array_pad($pets,10,'填充');
			 $this->pri($result);
			 $result = array_pad($pets,-10,'填充');
			 $this->pri($result);
			 return;

			 //对一个或多个数组,升(降)序排列,三参为强制指定数据类型
			 //多数组参数时二维数组好像有问题
			 array_multisort($pets,SORT_DESC);
			 $this->pri($pets);
			 array_multisort($double,SORT_DESC);
			 $this->pri($double);
			 $arr = array(1,2,'c',3);
			 array_multisort($arr,SORT_ASC,SORT_NUMERIC);
			 $this->pri($arr);
			 return;

			 //同下 数组合并,相同键名的键值不会覆盖,而是递归合并成新的二维数组
			 $arr = array(1,'a'=>2,3,4);
			 $this->pri(array_merge_recursive($pets));
			 return;

			 /**
			  * 数组合并,代替"+"作用
				* 多数组合并,重复键名会被最后一对键值对覆盖
				* 若仅一参【且键名是整数】,则函数会重排索引数组(从0)
			  */
				$arr = array(1,'a'=>2,3,4);
				$this->pri(array_merge($pets,$arr));
				$arr2 = array('1'=>6,'a'=>5);
				$this->pri(array_merge($arr,$arr2));

				$this->pri(array_merge($arr));
				return;

			 /**
			  * ※※※用自定义函数操作一个或多个数组的【值】
				* 一参为null 则合并各参数数组为一个二维数组,是同一键名合并...
				* 自定义函数参数个数等同于参数数组个数
			  */
				$arr = array(1,2,3,4);
				$this->pri(array_map(null,$pets,$arr));
				function map($v1,$v2){
					return ($v1.$v2);
				}
				$this->pri(array_map("map",$pets,$arr));
				return;

			 /**
			  * ※※※提取键名生成数组
				* 二参,只搜索指定键值的键名
				* 三参,是等于(==)搜索还是全等(===)搜索??三参有BUG??
			  */
			 $this->pri(array_keys($pets));
			 $arr = array(5,"5",2);
			 $this->pri(array_keys($arr),"5",false);
			 $this->pri(array_keys($arr),"5",true);
			 return;

			 //监测键名是否存在,二维数组只支持最外层键名
			 if (array_key_exists("a",$pets)) {
				 echo '键名存在!';
			 }
			 return;

			 /**
			  * 以下返回【交集】
			  */

				//比较键名,用用户自定义函数比较键名
				function myfunction($a,$b)
				{
				if ($a===$b)
				  {
				  return 0;
				  }
				  return ($a>$b)?1:-1;
				}

				$a1=array("a"=>"red","b"=>"green","c"=>"blue");
				$a2=array("a"=>"black","b"=>"yellow","d"=>"brown");
				$a3=array("e"=>"purple","f"=>"white","a"=>"gold");

				$result=array_intersect_ukey($a1,$a2,$a3,"myfunction");
				print_r($result);
				return;

				//比较键名与键值的交集,自定义函数比较键名
				function myfunction($a,$b)
				{
				if ($a===$b)
				  {
				  return 0;
				  }
				  return ($a>$b)?1:-1;
				}

				$a1=array("a"=>"red","b"=>"green","c"=>"blue");
				$a2=array("d"=>"red","b"=>"green","e"=>"blue");

				$result=array_intersect_uassoc($a1,$a2,"myfunction");
				print_r($result);
				return;

				//同下,比较键名
				$a1 = array('a'=>1,'b'=>2,'c'=>3);
				$a2 = array('c'=>2,'a'=>'balabala');
				$this->pri(array_intersect_key($a1,$a2));
				return;

				//同下比较键名个键值【键值对】
				$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
				$a2=array("a"=>"red","b"=>"green","g"=>"blue");
				$a3=array("a"=>"red","b"=>"green","g"=>"blue");
				$a4=array("%"=>"red","b"=>"green","g"=>"blue");
				$result=array_intersect_assoc($a1,$a2,$a3,$a4);
				print_r($result);
				return;

				//比较返回一个或多个数组 键值(value)的【交集】,以一参为基准
				$a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
				$a2=array("e"=>"red","f"=>"green","g"=>"blue");
				$a2=array('w'=>"red");
				$result=array_intersect($a1,$a2);
				print_r($result);
				return;

			 //键值翻转
			 //※※※如果同一值出现了多次，则最后一个键名将作为它的值，所有其他的键名都将丢失。
			 //数组元素 只支持字符串或整数
			 $this->pri(array_flip($pets));
			 $arr = array('a'=>1,'a'=>2,'b'=>3);
			 $this->pri(array_flip($arr));
			 $arr = array('a'=>1.23,'a'=>2.23,'b'=>3);
			 $this->pri(array_flip($arr));
			 return;

			//自定义函数过滤数组中每个【值】
			function test_odd($var)
			{
				//按位与
				return($var & 1);
			}
			$a1=array("a","b",2,3,4);
			print_r(array_filter($a1,"test_odd"));
			return;

			//用键名数组(一参)填充成数组
			$keys = array('a','b');
			$arr = array_fill_keys($keys,'value');
			$this->pri($arr);
			return;

			//数组填充,用键值填充成数组。
			$arr = array_fill(2,3,'value');
			$this->pri($arr);
			$arr = array(1=>'a',2=>'b');
				//"+"一下就成功了!!
			$arr += array_fill(3,2,'value');
			$this->pri($arr);
				return;

			/**
			 * 以下比较函数是返回【差集】
			 */
			//比较数组【键名】,同下,自定义函数
			function myfunction($a,$b)
			{
			if ($a===$b)
			  {
			  return 0;
			  }
			  return ($a<$b)?-1:+1;
			}

			$a1=array("a"=>"bed","b"=>"green","c"=>"blue");
			$a2=array("a"=>"rlue","b"=>"black","e"=>"blue");

			$result=array_diff_ukey($a1,$a2,"myfunction");
			print_r($result);
			return;


			//????比较数组【键值对】,同下函数,!!用自定义函数!!,自定义函数有什么用
			function myfunction($a,$b)
			{
			if ($a===$b)
			  {
			  return 0;
			  }
			  return ($a>$b)?-1:1;
			}

			$a1=array("a"=>"red","b"=>"green","c"=>"blue");
			$a2=array("a"=>"red","d"=>"blue");
			$a3=array("e"=>"yellow","a"=>"red","d"=>"blue");

			$result=array_diff_uassoc($a1,$a2,$a3,"myfunction");
			$this->pri($result);
			return;

			//比较数组【键名】,同下函数,必须成对满足添加才可
			$a1=array("a"=>"red","b"=>"green","c"=>"blue");
			$a2=array("c"=>"yellow","d"=>"black","e"=>"brown");
			$a3=array("f"=>"green","c"=>"purple","g"=>"red");
			$result=array_diff_key($a1,$a2,$a3);
			$this->pri($result);
			return;

			 //比较数组【键值对】,同下函数,必须成对满足添加才可
			 $a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
			 $a2=array("a"=>"red","f"=>"green","g"=>"blue");
			 $a3=array("h"=>"red","b"=>"green","g"=>"blue","c"=>'1');
			 $result=array_diff_assoc($a1,$a2,$a3);
			 $this->pri($result);
			 return;

			 //比较数组【值】,可多个数组与一参数组进行比较,返回差值数组
			 //高科技:该数组包括了所有在被比较的数组中，但是不在任何其他参数数组中的键值。
			 $a1=array("a"=>"red","b"=>"green","c"=>"blue","d"=>"yellow");
			 $a2=array("e"=>"red","f"=>"black","g"=>"purple");
			 $a3=array("a"=>"red","b"=>"black","h"=>"yellow");
			 $result=array_diff($a1,$a2,$a3);
	 		 $this->pri($result);
			 return;

			 //对所有值计数
			 $this->pri(array_count_values($pets));
			 return;

			 //合并两个数组来创建一个新数组，其中的一个数组是键名，另一个数组的值为键值。
			 //!!忽略俩数组的键名!!两数组元素个数不一样直接返回false(包含空)!!
			 $value = array('a'=>1,2,3,4);
			 $arr = array_combine($pets,$value);
			 $this->pri($arr);
			 return;

			 //※※※※※返回输入数组中某个单一列的值,三参为指定新生成数组键名(用原数组的什么?)
			 $arr = array_column($double,'first_name');
			 $this->pri($arr);
			 $arr = array_column($double,'first_name','id');
			 $this->pri($arr);
			 return;

			 //将数组(一维)分割为新的数组(二维)块,三参默认改为索引数组,true为用原数组
			 $this->pri(array_chunk($pets,2));
			 $this->pri(array_chunk($pets,2,true));
			 return;

			 //所有键名转换为大写,默认二参为转换成小写
			 $arr = array('a'=>1,'b'=>2);
			 $arr = array_change_key_case($arr,CASE_UPPER);
			 $this->pri($arr);
			 $arr = array_change_key_case($arr);
			 $this->pri($arr);
			 //特殊问题特殊处理,若转换后键名出现重复 则!后来覆盖!
			 print_r(array_change_key_case($pets,CASE_UPPER));
			 return;

			 //创建
			 array();
			 return;

			 //关联数组(指定键名),遍历用foreach
			 $arr = array('a'=>1,'b'=>2);
			 $this->pri($arr);
			 return;

			 //count
			 $arr = array('a','b');
			 echo count($arr);
			 return;

			 //索引数组,遍历用for即可
			 $arr = array('a','b');
			 $this->pri($arr);
			 return;
		 }
  }

 ?>
